const { spawn, exec } = require('child_process');
const net = require('net');
const path = require('path');

const PORT = process.env.PORT || 3001;
const SERVER_SCRIPT = path.join(__dirname, 'src', 'server.js');

/**
 * 检查端口是否被占用
 * @param {number} port 端口号
 * @returns {Promise<boolean>} 端口是否被占用
 */
function checkPortInUse(port) {
  return new Promise((resolve) => {
    const server = net.createServer();
    
    server.listen(port, () => {
      server.once('close', () => {
        resolve(false); // 端口未被占用
      });
      server.close();
    });
    
    server.on('error', () => {
      resolve(true); // 端口被占用
    });
  });
}

/**
 * 查找占用指定端口的进程PID
 * @param {number} port 端口号
 * @returns {Promise<string[]>} 进程PID列表
 */
function findProcessByPort(port) {
  return new Promise((resolve, reject) => {
    // 使用netstat命令查找占用端口的进程
    exec(`netstat -ano | findstr :${port}`, (error, stdout, stderr) => {
      if (error) {
        resolve([]); // 没有找到进程
        return;
      }
      
      const lines = stdout.split('\n');
      const pids = [];
      
      lines.forEach(line => {
        const parts = line.trim().split(/\s+/);
        if (parts.length >= 5 && parts[1].includes(`:${port}`)) {
          const pid = parts[4];
          if (pid && pid !== '0' && !pids.includes(pid)) {
            pids.push(pid);
          }
        }
      });
      
      resolve(pids);
    });
  });
}

/**
 * 停止指定PID的进程
 * @param {string} pid 进程ID
 * @returns {Promise<boolean>} 是否成功停止
 */
function killProcess(pid) {
  return new Promise((resolve) => {
    exec(`taskkill /F /PID ${pid}`, (error, stdout, stderr) => {
      if (error) {
        console.log(`⚠️ 无法停止进程 ${pid}: ${error.message}`);
        resolve(false);
      } else {
        console.log(`✅ 成功停止进程 ${pid}`);
        resolve(true);
      }
    });
  });
}

/**
 * 等待指定时间
 * @param {number} ms 毫秒数
 */
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

/**
 * 启动服务器
 */
function startServer() {
  console.log(`🚀 启动服务器: ${SERVER_SCRIPT}`);
  
  const serverProcess = spawn('node', [SERVER_SCRIPT], {
    stdio: 'inherit',
    cwd: __dirname
  });
  
  serverProcess.on('error', (error) => {
    console.error(`❌ 服务器启动失败: ${error.message}`);
    process.exit(1);
  });
  
  serverProcess.on('close', (code) => {
    console.log(`🔄 服务器进程退出，退出代码: ${code}`);
    if (code !== 0) {
      process.exit(code);
    }
  });
  
  // 处理进程退出信号
  process.on('SIGINT', () => {
    console.log('\n🛑 收到退出信号，正在停止服务器...');
    serverProcess.kill('SIGINT');
  });
  
  process.on('SIGTERM', () => {
    console.log('\n🛑 收到终止信号，正在停止服务器...');
    serverProcess.kill('SIGTERM');
  });
}

/**
 * 主函数
 */
async function main() {
  console.log(`🔍 检查端口 ${PORT} 是否被占用...`);
  
  const isPortInUse = await checkPortInUse(PORT);
  
  if (isPortInUse) {
    console.log(`⚠️ 端口 ${PORT} 已被占用，正在查找占用进程...`);
    
    const pids = await findProcessByPort(PORT);
    
    if (pids.length > 0) {
      console.log(`📋 找到 ${pids.length} 个占用端口的进程: ${pids.join(', ')}`);
      
      // 停止所有占用端口的进程
      for (const pid of pids) {
        await killProcess(pid);
      }
      
      // 等待进程完全停止
      console.log('⏳ 等待进程完全停止...');
      await sleep(2000);
      
      // 再次检查端口是否释放
      const stillInUse = await checkPortInUse(PORT);
      if (stillInUse) {
        console.log(`❌ 端口 ${PORT} 仍被占用，请手动检查并停止相关进程`);
        process.exit(1);
      } else {
        console.log(`✅ 端口 ${PORT} 已释放`);
      }
    } else {
      console.log(`⚠️ 无法找到占用端口 ${PORT} 的进程，可能是系统进程或权限不足`);
      console.log('请手动检查并停止相关进程，或使用其他端口');
      process.exit(1);
    }
  } else {
    console.log(`✅ 端口 ${PORT} 可用`);
  }
  
  // 启动服务器
  startServer();
}

// 运行主函数
main().catch((error) => {
  console.error(`❌ 启动过程中发生错误: ${error.message}`);
  process.exit(1);
});